package game;

import java.awt.Graphics2D;
import java.awt.event.MouseEvent;
import java.util.Random;
//import java.awt.geom.Point2D;
//TESTE

abstract class BaseLevel extends Scene
{
	Random random = new Random();

	public BaseLevel()
	{
		super();
		
		int valorMin = -5;
		int valorMax = 5;
		
	
		//MATRIZ OPOSTA
		double originalOposta[][] = RandomizarMatriz(2,3, valorMin, valorMax);
		System.out.println("***MATRIZ OPOSTA***\n\nORIGINAL\n" + DesenharMatriz(originalOposta, 2, 3));
		System.out.println("OPOSTA\n" + DesenharMatriz(OpostarMatriz(originalOposta, 2, 3), 2, 3));
		
		//SOMAR MATRIZES
		double oriSomar1[][] = RandomizarMatriz(3,3,valorMin, valorMax);
		double oriSomar2[][] = RandomizarMatriz(3,3,valorMin, valorMax);
		System.out.println("\n\n\n\n\n\n***SOMAR MATRIZ***\n\nORIGINAL1\n" + DesenharMatriz(oriSomar1, 3, 3));
		System.out.println("ORIGINAL2\n" + DesenharMatriz(oriSomar2, 3, 3));
		double resultSoma[][] = SomarMatrizes(oriSomar1, oriSomar2, 3, 3);
		System.out.println("SOMA\n" + DesenharMatriz(resultSoma, 3, 3));
		
		
		//DIMINUIR MATRIZES
		double oriDiminuir1[][] = RandomizarMatriz(3,3,valorMin, valorMax);
		double oriDiminuir2[][] = RandomizarMatriz(3,3,valorMin, valorMax);
		System.out.println("\n\n\n\n\n\n***DIMINUIR MATRIZ***\n\nORIGINAL1\n" + DesenharMatriz(oriDiminuir1, 3, 3));
		System.out.println("ORIGINAL2\n" + DesenharMatriz(oriDiminuir2, 3, 3));
		double resultDiminuir[][] = DiminuirMatrizes(oriDiminuir1, oriDiminuir2, 3, 3);
		System.out.println("SOMA\n" + DesenharMatriz(resultDiminuir, 3, 3));

				
				
		//TRANSPOR MATRIZ
		double originalTransposta[][] = RandomizarMatriz(3,3,valorMin, valorMax);
		System.out.println("\n\n\n\n\n\n***TRANSPOR MATRIZ***\n\nORIGINAL\n" + DesenharMatriz(originalTransposta, 3, 3));
		double resultTransposta[][] = TransportarMatriz(originalTransposta);
		System.out.println("TRANSPOSTA\n" + DesenharMatriz(resultTransposta, 3, 3));
		
		
		//MULTIPLICAR MATRIZ POR NUMERO
		double originalMultiplicacao[][] = RandomizarMatriz(3,3,valorMin, valorMax);
		int multiplicador = -50 + random.nextInt(50- (-50));
		System.out.println("\n\n\n\n\n\n***MULTIPLICAR MATRIZ POR NUMERO***\n\nORIGINAL\n" + DesenharMatriz(originalMultiplicacao, 3, 3));
		System.out.println("MULTIPLICADOR DA MATRIZ\n" + multiplicador);
		double resultMultiplicacao[][] = MultiplicarMatriz(originalMultiplicacao, multiplicador, 3, 3);
		System.out.println("\nMATRIZ MULTIPLICADA POR NUMERO\n" + DesenharMatriz(resultMultiplicacao, 3, 3));
		
		
		//MULTIPLICAR MATRIZ POR MATRIZ
		double originalMultiplicacao1[][] = RandomizarMatriz(2,3,valorMin, valorMax);
		double originalMultiplicacao2[][] = RandomizarMatriz(2,2,valorMin, valorMax);
		System.out.println("\n\n\n\n\n\n***MULTIPLICAR MATRIZ POR MATRIZ***\n\nORIGINAL1\n" + DesenharMatriz(originalMultiplicacao1, 2, 3));
		System.out.println("ORIGINAL2\n" + DesenharMatriz(originalMultiplicacao2, 2, 2));
		double resultMultiplicacaoMatrizes[][] = MultiplicarMatriz(originalMultiplicacao1,originalMultiplicacao2, 2, 3, 2, 2);
		System.out.println("\nMATRIZ MULTIPLICADA POR MATRIZ\n" + DesenharMatriz(resultMultiplicacaoMatrizes, 2, 3));
		
	}

	public void update()
	{
        if (Mouse.getInstance().isMousePressed(MouseEvent.BUTTON1))
        {
        	//System.out.print("LOL");
        }
    }

	public void draw(Graphics2D g2d)
	{
	}

	public void DeterminanteMatriz(double numeros[][])
	{
		
		double num[][];

		System.out.println(DesenharMatriz(numeros, numeros.length, numeros.length));
		Double total = (double)0;
		
		if(numeros.length == 1)
		{
			total = numeros[0][0];
		}
		else if(numeros.length == 2)
		{
			num = numeros;
			total += num[0][0] * num[1][1];
			total -= num[1][0] * num[0][1];
		}
		else if(numeros.length == 3)
		{
			num = new double[(numeros.length*2)-1][numeros.length];
			for(int x = 0; x < (numeros.length*2)-1; x++)
			{
				for(int y = 0; y < numeros.length; y++)
				{
					if(x >= numeros.length)
						num[x][y] = numeros[x - numeros.length][y];
					else
						num[x][y] = numeros[x][y];
				}
			}
			
			System.out.println(DesenharMatriz(num, numeros.length, (numeros.length*2)-1 ));
			
			total += num[0][0] * num[1][1] *  num[2][2];
			total += (num[1][0] * num[2][1] *  num[3][2]);
			total += (num[2][0] * num[3][1] *  num[4][2]);
			
			
			total -= num[2][2] * num[3][1] *  num[4][0];
			total -= num[1][2] * num[2][1] *  num[3][0];
			total -= num[0][2] * num[1][1] *  num[2][0];
		}
		
		System.out.println("TOTAL: " + total);
	}

	public String DesenharMatriz(double matriz[][], int numColunas, int numLinhas)
	{
		String texto2 = "";
		for(int y = 0; y < numLinhas; y++)
		{
			texto2 += "|	";
			for(int x = 0; x < numColunas; x++)
			{
				texto2 += matriz[x][y] + "	";
			}
			texto2 += "|\n";
		}
		return texto2;
	}
	
	public double[][] TransportarMatriz(double numeros[][])
	{
		double numeros2[][] = new double[numeros.length][numeros.length];
		
		for(int x = 0; x < numeros.length; x++)
		{
			for(int y = 0; y < numeros.length; y++)
			{
				numeros2[x][y] = numeros[y][x];
			}
		}
		return numeros2;
	}
	
	public double[][] RandomizarMatriz(int numColunas, int numLinhas)
	{
		double matriz[][] = new double[numColunas][numLinhas];
		
		for(int x = 0; x < numColunas; x++)
			for(int y = 0; y < numLinhas; y++)
				matriz[x][y] = Double.parseDouble(random.nextInt(99) + "." + random.nextInt(99));
		
		return matriz;
	}

	public double[][] SomarMatrizes(double matriz1[][], double matriz2[][], int numColunas, int numLinhas)
	{
		double total[][] = new double[numColunas][numLinhas];
		
		for(int x = 0; x < numColunas; x++)
			for(int y = 0; y < numLinhas; y++)
				total[x][y] = matriz1[x][y] + matriz2[x][y];
		
		
		return total;
	}

	public double[][] DiminuirMatrizes(double matriz1[][], double matriz2[][], int numColunas, int numLinhas)
	{
		double total[][] = new double[numColunas][numLinhas];
		
		for(int x = 0; x < numColunas; x++)
			for(int y = 0; y < numLinhas; y++)
				total[x][y] = matriz1[x][y] - matriz2[x][y];
		
		
		return total;
	}

	public double[][] MultiplicarMatriz(double matriz[][], double multiplicador, int numColunas, int numLinhas)
	{
		double total[][] = new double[numColunas][numLinhas];
		
		for(int x = 0; x < numColunas; x++)
			for(int y = 0; y < numLinhas; y++)
				total[x][y] = multiplicador * matriz[x][y];
		
		
		return total;
	}
	
	public double[][] MultiplicarMatriz(double matriz[][], double matriz2[][], int numColunas1, int numLinhas1, int numColunas2, int numLinhas2)
	{
		double total[][] = new double[numColunas2][numLinhas1];
		
		for(int x2 = 0; x2 < numColunas2; x2++)
		{
			for(int y1 = 0; y1 < numLinhas1; y1++)
			{
				total[x2][y1] = (matriz[0][y1]*matriz2[x2][0]) +  (matriz[1][y1]*matriz2[x2][1]);
				//String str = "" + x2 + y1;
				//System.out.println(Double.parseDouble(str));
				//total[x2][y1] = Double.parseDouble(str);	
			}
		}
	
		return total;
	}

	public double[][] OpostarMatriz(double matriz[][], int numColunas, int numLinhas)
	{
		double total[][] = new double[numColunas][numLinhas];
		
		for(int x = 0; x < numColunas; x++)
			for(int y = 0; y < numLinhas; y++)
				total[x][y] = matriz[x][y] * -1;
		
		
		return total;
	}
}
